Goose_Base Class Reference

A class to describe the goose base. More...

#include <Goose_Base.h>

Inheritance diagram for Goose_Base:

Public Member Functions
	Goose_Base (Landscape *p_L, Goose_Population_Manager *p_NPM, double a_weight, bool a_sex, APoint a_roost)
	Goose_Base constructor. More...
void	Init (Goose_Population_Manager *p_NPM, double a_weight, bool a_sex, APoint a_roost)
	Intitialise object. More...
void	ReInit (Landscape *p_L, Goose_Population_Manager *p_NPM, double a_weight, bool a_sex, APoint a_roost)
	ReInit for object pool. More...
virtual	~Goose_Base ()
	Goose_Base destructor. More...
void	st_Dying (void)
	Behavioural state dying. More...
void	Explore ()
	Behavioural exploration of the area to find forage. More...
TTypeOfGoose_BaseState	st_Forage ()
	Behavioural forage. More...
virtual TTypeOfGoose_BaseState	st_ToRoost ()
	Return to roost and assess whether to forage again that day. More...
APoint	GetRoost ()
	Supply roost coords. More...
TMaxIntakeSource	GetMaxIntakeSource ()
	Supply the current max intake source. More...
virtual void	ChangeRoost ()
	Find the closest roost. More...
TTypeOfGoose_BaseState	st_Roost ()
	Roosting until next forage or next morning. More...
virtual APoint	ChooseHopLoc ()
	Pick a hop location point within a_dist meters - must be overridden by descendent classes. More...
void	EvaluateForageToHopLoc (APoint a_HopLoc)
	Do a forage evaluation from current location to a_HopLoc. More...
virtual void	StartDay (void)
	Do any 'housekeeping' associated with the start of day. More...
virtual void	BeginStep (void)
	The BeginStep is the first 'part' of the timestep that an animal can behave in. It is called once per timestep (10 minutes). More...
virtual void	Step (void)
	The Step is the second 'part' of the timestep that an animal can behave in. It is called continuously until all animals report that they are 'DONE'. More...
virtual void	EndStep (void)
	The EndStep is the third 'part' of the timestep that an animal can behave in. It is called once per timestep. More...
virtual void	On_Emigrate ()
	Cause the bird to immediately transition to Emigrate. More...
double	GetBodyCondition ()
	Returns the current body condition. More...
void	SetBodyCondition (double a_condition, unsigned a_index)
	Sets the current body condition. More...
void	AddBodyCondition (double a_condition)
	Alters body conditon by addition of a double value. More...
void	SubtractBodyCondition (double a_condition)
	Alters body conditon by subtraction of a double value. More...
int	GetGroupsize ()
	Returns the groupsize. More...
double	ScaleForageToGroupsize (double a_forage)
	Scales forage to groupsize. More...
int	GetForageLocIndex ()
	Gets for the forage location index. More...
GooseSpecies	GetSpecies ()
	Returns the species. More...
bool	GetSex ()
	Returns the sex. More...
int	GetMaxAppetiteHitTime ()
	Returns m_DailyMaxAppetiteHitTime. More...
int	GetFlightNumber ()
	Returns the total daily number of flights. More...
int	GetFlightDistance ()
	Returns the total daily distance flown. More...
double	GetDailyEnergyBudget ()
	Returns the daily energy budget. More...
double	GetDailyEnergyExpenditure ()
	Returns the daily energy expenditure. More...
int	GetForagingTime (int a_EndForagingTime, double a_RoostLeaveTime)
	Returns the time spent foraging. More...
double	GetGooseMinForageRate (GooseSpecies a_species)
	Returns the minimum forage rate for the species. More...
double	GetMaxForageRate (double a_grain, double a_maize, double a_grass, double a_interferenceComp, bool a_iscereal, TTypesOfVegetation a_veg, bool a_stubble, TTypesOfVegetation a_prevcrop)
	Returns the max forage rate of the three different types of forage The max rate is adjusted according to feeding time in the time budget, according to the interference competition value and to the current snow depth in the landscape. More...
double	GetMaxIntakeRate (double a_grain, double a_maize, double a_grass)
	Returns the max intake rate of the three different types of intake. More...
void	SetSex (bool a_sex)
	Sets the sex. More...
double	GetTotalWeight ()
	Returns the weight of the bird. More...
double	GetRoostLeaveTime ()
	Returns the time when the goose leaves the roost. More...
void	SetFlightCost (double a_cost)
	Set the flight cost per m per g. More...
double	GetFlightCost ()
	Get the flight costs per m per g. More...
void	Set_mingooseforagerate (double a_cost, GooseSpecies a_species)
	Set the mimimum tolerated forage rate for all geese. More...
void	Set_Indivmingooseforagerate (double a_cost)
	Set the mimimum tolerated forage rate for the individual goose. More...
void	Set_GooseLeavingThreshold (double a_threshold)
	Set the body condition threshold for leaving for all geese. More...
void	Set_GooseMaxAppetiteScaler (double a_cost)
	Set the goose appetite scale used to calculate max intake for all geese. More...
void	Set_GooseMaxEnergyReserveProportion (double a_prop)
	Set the maximum energy reserve proportion allowed for all geese. More...
void	Set_GooseKJtoFatConversion (double a_cost)
	Set the kJ to fat conversion constant for all geese. More...
void	Set_GooseFattoKJConversion (double a_cost)
	Set the fat to kJ conversion constant for all geese. More...
void	Set_GooseMinForageOpenness (double a_cost)
	Set the min forage openess for all geese. More...
void	Set_GooseForageDist (double sp1, double sp2, double sp3)
	Set the max forage distance from roost for all geese. More...
void	Set_GooseFieldForageDist (double sp1, double sp2, double sp3)
	Set the max forage distance from a field for all geese. More...
void	Set_GooseFollowingLikelyhood (int a_likelyhood, GooseSpeciesType a_speciestype)
	Set the followinglikelyhood. More...
void	Set_GooseLeavingRoost (bool a_leaving)
	Set the flag to indicate if we are coming from the roost. More...
void	On_MoveTo (int a_x, int a_y)
	The goose is moved to the location specified by a_x, a_y - caused by group decision. More...
virtual void	KillThis ()
	The bird is dead of some external cause. More...
void	On_Bang (int a_polyid)
	The goose is scared by a bang at location. More...
void	On_Bang (int a_polyid, double a_scare)
	The goose is scared by a bang at location. More...
void	On_Migrate (TTypeOfLeaveReason a_leavereason)
	The goose is told to leave the simulation area (poss due to bad weather) More...
double	AdjustIntakeRateToSnowDepth (double a_intakerate)
	When there is snow, the intake rate is decreased by 10 % per cm of snow. More...
Public Member Functions inherited from TAnimal
unsigned	SupplyFarmOwnerRef ()
AnimalPosition	SupplyPosition ()
APoint	SupplyPoint ()
int	SupplyPolygonRef ()
int	Supply_m_Location_x ()
int	Supply_m_Location_y ()
virtual void	CopyMyself ()
void	SetX (int a_x)
void	SetY (int a_y)
	TAnimal (int x, int y, Landscape *L)
virtual void	ReinitialiseObject (int x, int y, Landscape *L)
	Used to re-use an object - must be implemented in descendent classes. More...
virtual int	WhatState ()
virtual void	Dying ()
void	CheckManagement (void)
void	CheckManagementXY (int x, int y)
virtual bool	OnFarmEvent (FarmToDo)
Public Member Functions inherited from TALMaSSObject
int	GetCurrentStateNo ()
	Returns the current state number. More...
void	SetCurrentStateNo (int a_num)
	Sets the current state number. More...
bool	GetStepDone ()
	Returns the step done indicator flag. More...
void	SetStepDone (bool a_bool)
	Sets the step done indicator flag. More...
virtual void	ReinitialiseObject ()
	Used to re-use an object - must be implemented in descendent classes. More...
	TALMaSSObject ()
	The constructor for TALMaSSObject. More...
virtual	~TALMaSSObject ()
	The destructor for TALMaSSObject. More...
void	OnArrayBoundsError ()
	Used for debugging only, tests basic object properties. More...

Protected Member Functions
TTypeOfGoose_BaseState	st_ChooseForageLocation (void)
	Selects a forage location based on past memory, or initiates an exploration. More...
void	FlyTo (int a_x, int a_y)
	The goose flys to the location specified by a_x, a_y. More...
void	FlyTo (APoint a_pt)
	The goose flys to the location specified by a_pt. More...
Protected Member Functions inherited from TAnimal
void	CorrectWrapRound ()
	Corrects wrap around co-ordinate problems. More...

Protected Attributes
TTypeOfGoose_BaseState	CurrentGState
	Variable to record current behavioural state. More...
Goose_Population_Manager *	m_OurPopulationManager
	This is a time saving pointer to the correct population manager object. More...
bool	m_sex
	Sex of bird, true = male false = female. More...
GooseSpecies	m_myspecies
	Holds goose species. More...
GooseSpeciesType	m_myGooseSpeciesType
	Holds the goose species type. More...
APoint	m_MyRoost
	The current roost location. More...
int	m_groupsize
	The size of the group this bird represents. More...
double	m_weight
	The weight of the bird in gram excluding fat reserve. More...
double	m_weightTotal
	The weight of the bird in g including fat reserve. More...
int	m_forageLocCount
	The number of forage locations visited today. More...
double	m_BMR
	The daily BMR. More...
double	m_DEB
	The daily energy budget excluding flying (kJ) More...
double	m_DailyMaxAppetite
	The daily max kJ possible to get as intake. More...
int	m_DailyMaxAppetiteHitTime
	The time of day when m_DailyMaxAppetite was hit. More...
double	m_energyToday
	The bird's daily energy account (kJ) More...
TMaxIntakeSource	m_MaxIntakeSource
	Holds information about the food source which gave max intake rate. More...
double	m_LeaveRoostTime
	Controls the time when the goose will leave the roost. More...
bool	m_LeavingRoost
	Flag to indicate that we are coming from the roost. Used to control code for "following". More...
double	m_energyReserve
	The bird's energy reserves in grams. More...
double	m_Indivmingooseforagerate
	The minimum tolerable forage rate in kJ/minute for the individual. More...
double	m_BodyCondition [5]
	A variable describing current body condition over the past 5 days. More...
double	m_TheBodyCondition
	A variable describing current body condition averaged over 5 days. More...
unsigned	m_BodyConditionCounter
	A counter for the daily body condition. More...
int	m_myForageIndex
	Temporary storage for a forage location index - this is a speed optimisation. More...
int	m_myMemPolyID
	Temporary storage for a memory location polygon id. More...
GooseMemoryMap *	m_MyMemory
	The Goose Memory. More...
int	m_FlightNumber
	Counter for the number of flights per day. More...
int	m_FlightDistance
	Storage for the total distance flown per day. More...
Protected Attributes inherited from TAnimal
int	m_Location_x
int	m_Location_y
Landscape *	m_OurLandscape
Protected Attributes inherited from TALMaSSObject
int	m_CurrentStateNo
	The basic state number for all objects - '-1' indicates death. More...
bool	m_StepDone
	Indicates whether the iterative step code is done for this timestep. More...

Static Protected Attributes
static double	m_SnowDepth = 0.0
	The current snow depth. Held here for speed optimization. More...
static double	m_flightcost = -1
	The cost of flight per g per m in kJ. More...
static double	m_mingooseforagerate [gs_foobar] = { -1, -1, -1 }
	The minimum tolerable forage rate in kJ/minute for the species. More...
static double	m_GooseForageDist [gs_foobar] = { -1, -1, -1 }
	The maximum distance travelled from roost to forage sites for each species of goose (m) More...
static double	m_GooseForageDistX2 [gs_foobar] = { -1, -1, -1 }
	Double the maximum distance travelled from roost to forage sites for each species of goose (m) - this is a speed optimisation. More...
static double	m_GooseFieldForageDist [gs_foobar] = { -1, -1, -1 }
	The maximum distance travelled from roost to forage sites for each species of goose (m) More...
static double	m_GooseFieldForageDistX2 [gs_foobar] = { -1, -1, -1 }
	Double the maximum distance travelled from roost to forage sites for each species of goose (m) - this is a speed optimisation. More...
static double	m_GooseLeavingThreshold = -1
	The trigger for leaving as a 5 day average of body condition. More...
static double	m_GooseMaxAppetiteScaler = -1
	Scaler to determine the max kJ possible to eat per day based on non-energy reserve weight. More...
static double	m_GooseMaxEnergyReserveProportion = -1
	Max proportion of weight that can be energy reserve. More...
static double	m_GooseKJtoFatConversion = -1
	Conversion rate kJ to fat. More...
static double	m_GooseFattoKJConversion = -1
	Conversion rate fat to kJ. More...
static double	m_GooseMinForageOpenness = -1
	The minimum openness value a goose will tolerate for forage. More...
static int	m_followinglikelyhood [(int) gst_foobar] = { -1, -1, -1 , -1, -1, -1 }
	An attribute used to determine the chance of following or exploring when foraging. More...

Detailed Description

A class to describe the goose base.

Constructor & Destructor Documentation

Goose_Base()

Goose_Base::Goose_Base	(	Landscape *	p_L,
		Goose_Population_Manager *	p_NPM,
		double	a_weight,
		bool	a_sex,
		APoint	a_roost
	)

Goose_Base constructor.

                                                                                                                   : TAnimal(0, 0, p_L)
{
    Init(p_NPM, a_weight, a_sex, a_roost);
}

References Init().

~Goose_Base()

Goose_Base::~Goose_Base ( void  )

virtual

Goose_Base destructor.

{
    if (m_MyMemory!=NULL) delete m_MyMemory;
}

References m_MyMemory.

Member Function Documentation

AddBodyCondition()

void Goose_Base::AddBodyCondition ( double  a_condition )

inline

Alters body conditon by addition of a double value.

{ m_TheBodyCondition += a_condition; }

References m_TheBodyCondition.

Referenced by StartDay().

AdjustIntakeRateToSnowDepth()

double Goose_Base::AdjustIntakeRateToSnowDepth

(

double

a_intakerate

)

When there is snow, the intake rate is decreased by 10 % per cm of snow.

                                                                  {
    if (m_SnowDepth > 0.0) {
        a_intakerate = a_intakerate * (1 - (m_SnowDepth * cfg_goose_snow_scaler.value()));
    }
    return a_intakerate;
}

References cfg_goose_snow_scaler, m_SnowDepth, and CfgFloat::value().

Referenced by GetMaxForageRate().

BeginStep()

virtual void Goose_Base::BeginStep ( void  )

inlinevirtual

The BeginStep is the first 'part' of the timestep that an animal can behave in. It is called once per timestep (10 minutes).

Reimplemented from TAnimal.

{ StartDay(); }

References StartDay().

ChangeRoost()

virtual void Goose_Base::ChangeRoost ( )

inlinevirtual

Find the closest roost.

Reimplemented in Goose_Pinkfoot_Base, Goose_Greylag_Base, and Goose_Barnacle_Base.

{ ; }

ChooseHopLoc()

virtual APoint Goose_Base::ChooseHopLoc ( )

inlinevirtual

Pick a hop location point within a_dist meters - must be overridden by descendent classes.

Reimplemented in Goose_Pinkfoot_Base, Goose_Greylag_Base, and Goose_Barnacle_Base.

{ return m_MyRoost; }  

References m_MyRoost.

Referenced by Explore().

EndStep()

virtual void Goose_Base::EndStep ( void  )

inlinevirtual

The EndStep is the third 'part' of the timestep that an animal can behave in. It is called once per timestep.

Reimplemented from TAnimal.

Reimplemented in Goose_Pinkfoot_FamilyGroup, Goose_Greylag_FamilyGroup, and Goose_Barnacle_FamilyGroup.

{} // NB this is not used in the Goose_Base code

EvaluateForageToHopLoc()

void Goose_Base::EvaluateForageToHopLoc

(

APoint

a_HopLoc

)

Do a forage evaluation from current location to a_HopLoc.

Moves along the vector between the current location and a_HopLoc testing forage for each polygon encountered along the way. This will build up the goose' memory.

Parameters

[in]

a_HopLoc

A point in the landscape.

{
    double dx = a_HopLoc.m_x - m_Location_x;
    double dy = a_HopLoc.m_y - m_Location_y;
    int dist = g_AlmassMathFuncs.CalcDistPythagoras( a_HopLoc.m_x, a_HopLoc.m_y, m_Location_x, m_Location_y );
    double tx = m_Location_x;
    double ty = m_Location_y;
    // We are looking for big things, so no need to move at 1m steps
    double ddx = (dx/dist)*100;
    double ddy = (dy/dist)*100;
    int lastpoly = m_OurLandscape->SupplyPolyRef(m_Location_x, m_Location_y);
    for (int d=0; d<dist/100; d++)
    {
        tx += ddx;
        ty += ddy;
            if (m_OurLandscape->SupplyPolyRef((int)tx, (int)ty) != lastpoly)
            {
                lastpoly = m_OurLandscape->SupplyPolyRef((int)tx, (int)ty);
                int openness = (int)m_OurLandscape->SupplyOpenness(lastpoly); // Score calculated by Landscape::CaclulateOpenness
                if (openness >= m_GooseMinForageOpenness)
                {
                    GooseMemoryLocation aThought;
                    double grain = m_OurLandscape->SupplyBirdSeedForage(lastpoly); // grain/m2
                    double maize = m_OurLandscape->SupplyBirdMaizeForage(lastpoly); // kJ/m2
                    aThought.m_grain = m_OurPopulationManager->GetFeedingRate(grain, m_myspecies); // kJ/min
                    aThought.m_maize = m_OurPopulationManager->GetMaizeFeedingRate(maize, m_myspecies); // kJ/min
                    aThought.m_grazing = m_OurLandscape->GetActualGooseGrazingForage(lastpoly, m_myspecies); // kJ/min
                    aThought.m_foodresource = GetMaxIntakeRate(aThought.m_grain, aThought.m_maize, aThought.m_grazing);
                    if (aThought.m_foodresource > 0)  // don't remember poor food locations
                    {
                        aThought.m_polygonid = lastpoly;
                        aThought.m_x = m_OurLandscape->SupplyCentroidX(lastpoly);
                        aThought.m_y = m_OurLandscape->SupplyCentroidY(lastpoly);
                        aThought.m_threat = 0;
                        int the_dist = g_AlmassMathFuncs.CalcDistPythagorasApprox(m_MyRoost.m_x, m_MyRoost.m_y, aThought.m_x, aThought.m_y);
                        aThought.m_score = m_MyMemory->CalcScore(the_dist, aThought.m_foodresource, aThought.m_threat);
                        m_MyMemory->MemAdd(aThought);
                    }
                }
            }
        }
 
}

References ALMaSS_MathFuncs::CalcDistPythagoras(), ALMaSS_MathFuncs::CalcDistPythagorasApprox(), GooseMemoryMap::CalcScore(), g_AlmassMathFuncs, Landscape::GetActualGooseGrazingForage(), Goose_Population_Manager::GetFeedingRate(), Goose_Population_Manager::GetMaizeFeedingRate(), GetMaxIntakeRate(), GooseMemoryLocation::m_foodresource, m_GooseMinForageOpenness, GooseMemoryLocation::m_grain, GooseMemoryLocation::m_grazing, TAnimal::m_Location_x, TAnimal::m_Location_y, GooseMemoryLocation::m_maize, m_MyMemory, m_MyRoost, m_myspecies, TAnimal::m_OurLandscape, m_OurPopulationManager, GooseMemoryLocation::m_polygonid, GooseMemoryLocation::m_score, GooseMemoryLocation::m_threat, APoint::m_x, GooseMemoryLocation::m_x, APoint::m_y, GooseMemoryLocation::m_y, GooseMemoryMap::MemAdd(), Landscape::SupplyBirdMaizeForage(), Landscape::SupplyBirdSeedForage(), Landscape::SupplyCentroidX(), Landscape::SupplyCentroidY(), Landscape::SupplyOpenness(), and Landscape::SupplyPolyRef().

Referenced by Goose_Barnacle_Base::ChooseHopLoc(), Goose_Greylag_Base::ChooseHopLoc(), and Goose_Pinkfoot_Base::ChooseHopLoc().

Explore()

void Goose_Base::Explore

(

)

Behavioural exploration of the area to find forage.

This behaviour can be invoked either from the roost or from another location. If from another location then there is an initial move followed by an exploration of the area directly on route to the chosen location. If from the roost then a distance and direction is chosen for the explore. In both cases the movement has energetic costs associated with the flight.

{
    APoint HopLoc;
    for (int i = 0; i < 1; i++)
    {
        HopLoc = ChooseHopLoc(); // The distance moved is dependent on the species and this is controlled by the inherited ChooseHopLoc code.
    }
    FlyTo( HopLoc );
}

References ChooseHopLoc(), and FlyTo().

Referenced by st_ChooseForageLocation().

FlyTo() [1/2]

void Goose_Base::FlyTo ( APoint  a_pt )

protected

The goose flys to the location specified by a_pt.

{
    FlyTo(a_pt.m_x,a_pt.m_y);
}

References FlyTo(), APoint::m_x, and APoint::m_y.

FlyTo() [2/2]

void Goose_Base::FlyTo ( int  a_x, int  a_y  )

protected

The goose flys to the location specified by a_x, a_y.

Moves the bird from m_Location_x,m_Location_y to a_x,a_y. Assumes that the cost of flight is directly proportional to the distance x bird weight. The cost is calcuated and removed from the energy reserve. To save some calculation costs (sqrt is expensive in time) we use an approximation to Pythagorus accurate to around 6%. m_weightTotal is in grams and m_flightcost the cost of moving 1 gram per m, all distances in meters. NB all flying trips are assumed to take 10 minutes but the energy used is determined by the distance.

and sets the new location

and finally store the information about flight number and distance

{
    if ((m_Location_x == a_x) && (m_Location_y == a_y)) return;
    int dist = g_AlmassMathFuncs.CalcDistPythagorasApprox( m_Location_x, m_Location_y, a_x, a_y );
    double cost = dist * GetFlightCost();
    m_energyToday-=cost;
    m_Location_x = a_x;
    m_Location_y = a_y;
    m_FlightNumber++;
    m_FlightDistance += dist;
 
}

References ALMaSS_MathFuncs::CalcDistPythagorasApprox(), g_AlmassMathFuncs, GetFlightCost(), m_energyToday, m_FlightDistance, m_FlightNumber, TAnimal::m_Location_x, and TAnimal::m_Location_y.

Referenced by Explore(), FlyTo(), On_MoveTo(), st_ChooseForageLocation(), Goose_Barnacle_Base::st_ToRoost(), Goose_Greylag_Base::st_ToRoost(), and Goose_Pinkfoot_Base::st_ToRoost().

GetBodyCondition()

double Goose_Base::GetBodyCondition ( )

inline

Returns the current body condition.

{ return m_TheBodyCondition; }

References m_TheBodyCondition.

GetDailyEnergyBudget()

double Goose_Base::GetDailyEnergyBudget ( )

inline

Returns the daily energy budget.

                                 {
       return m_DEB;
   }

References m_DEB.

GetDailyEnergyExpenditure()

double Goose_Base::GetDailyEnergyExpenditure ( )

inline

Returns the daily energy expenditure.

                                      {
       return m_energyToday;
   }

References m_energyToday.

GetFlightCost()

double Goose_Base::GetFlightCost ( )

inline

Get the flight costs per m per g.

                          {
       return m_flightcost * m_weightTotal;
   }

References m_flightcost, and m_weightTotal.

Referenced by FlyTo().

GetFlightDistance()

int Goose_Base::GetFlightDistance ( )

inline

Returns the total daily distance flown.

                           {
       return m_FlightDistance;
   }

References m_FlightDistance.

GetFlightNumber()

int Goose_Base::GetFlightNumber ( )

inline

Returns the total daily number of flights.

                         {
       return m_FlightNumber;
   }

References m_FlightNumber.

GetForageLocIndex()

int Goose_Base::GetForageLocIndex ( )

inline

Gets for the forage location index.

{ return m_myForageIndex; }

References m_myForageIndex.

Referenced by Goose_Population_Manager::GetLeader(), and st_ChooseForageLocation().

GetForagingTime()

int Goose_Base::GetForagingTime	(	int	a_EndForagingTime,
		double	a_RoostLeaveTime
	)

Returns the time spent foraging.

Parameters

[in]	a_EndForagingTime	The time of day where a goose hits it's daily max intake
[in]	a_RoostLeaveTime	The time of day where a goose leaves the roost

Returns

The difference between roost leave time and end foraging time

{
    int foraging_time = -1;
    int day_length = m_OurLandscape->SupplyDaylength();
    int roost_leave_time = (int)a_RoostLeaveTime;
    if (roost_leave_time < 0) {
        roost_leave_time = 0;
    }
    // If they never hit their daily max, they are assigned 1440.
    if (a_EndForagingTime == 1440)
    {
        foraging_time = day_length - roost_leave_time;
    }
    else
    {
        foraging_time = a_EndForagingTime - roost_leave_time;
    }
    if (foraging_time == -1)
    {
        m_OurLandscape->Warn("Goose_Base::CalcForagingTime()","error in foraging time calculation");
        exit(0);
    }
    return foraging_time;
}

References TAnimal::m_OurLandscape, Landscape::SupplyDaylength(), and Landscape::Warn().

Referenced by StartDay().

GetGooseMinForageRate()

double Goose_Base::GetGooseMinForageRate ( GooseSpecies  a_species )

inline

Returns the minimum forage rate for the species.

Parameters

[in]

a_species

The type of goose species

Returns

The minimum forage rate the goose will accept.

   {
       return m_mingooseforagerate[a_species];
   }

References m_mingooseforagerate.

Referenced by st_Forage().

GetGroupsize()

int Goose_Base::GetGroupsize ( )

inline

Returns the groupsize.

{ return m_groupsize; }

References m_groupsize.

Referenced by Goose_Population_Manager::DoLast(), and AOR_Probe_Goose::DoProbe().

GetMaxAppetiteHitTime()

int Goose_Base::GetMaxAppetiteHitTime ( )

inline

Returns m_DailyMaxAppetiteHitTime.

                               {
       return m_DailyMaxAppetiteHitTime;
   }

References m_DailyMaxAppetiteHitTime.

GetMaxForageRate()

double Goose_Base::GetMaxForageRate ( double  a_grain, double  a_maize, double  a_grass, double  a_interferenceComp, bool  a_iscereal, TTypesOfVegetation  a_veg, bool  a_stubble, TTypesOfVegetation  a_prevcrop  )

inline

Returns the max forage rate of the three different types of forage The max rate is adjusted according to feeding time in the time budget, according to the interference competition value and to the current snow depth in the landscape.

Parameters

[in]	a_grain	The intake rate from the grain resource
[in]	a_maize	The intake rate from the maize resource
[in]	a_grass	The intake rate from the grazing resource
[in]	a_interferenceComp	The scaler for interference competition
[in]	a_iscereal	Flag for a cereal crop or not (false)
[in]	a_veg	The vegetation type
[in]	a_stubble	Flag for a crop in stubble or not (false)
[in]	a_prevcrop	The previously sown crop

Returns

The max forage rate scaled to time budget and interference competetion

                                                                                                                                                                                                {
       double MaxRate = 0.0;
       if (a_grain > MaxRate) {
           MaxRate = a_grain;
           m_MaxIntakeSource.m_maxintakesource = tomis_grain;
       }
       else if (a_maize > MaxRate) {
           MaxRate = a_maize;
           m_MaxIntakeSource.m_maxintakesource = tomis_maize;
       }
       else if (a_grass > MaxRate) {
           MaxRate = a_grass;
           if (a_iscereal == false) m_MaxIntakeSource.m_maxintakesource = tomis_grass; else m_MaxIntakeSource.m_maxintakesource = tomis_sowncrop;
       }
       else
       {
           MaxRate = 0;
           m_MaxIntakeSource.m_maxintakesource = tomis_foobar;
       }
       MaxRate *= a_interferenceComp;
       MaxRate = AdjustIntakeRateToSnowDepth(MaxRate);
       m_MaxIntakeSource.m_iscereal = a_iscereal;
       m_MaxIntakeSource.m_instubble = a_stubble;
       m_MaxIntakeSource.m_veg = a_veg;
       m_MaxIntakeSource.m_prevsowncrop = a_prevcrop;
       /**** CJT DEBUG ****
       if ((a_stubble) && (!a_iscereal) && (m_MaxIntakeSource.m_maxintakesource == tomis_grain))
       {
           g_msg->WarnAddInfo(WARN_BUG, "Day ", m_OurLandscape->SupplyDayInYear());
           g_msg->WarnAddInfo(WARN_BUG, "Veg ", a_veg);
           g_msg->WarnAddInfo(WARN_BUG, "Prev Crop ", a_prevcrop);
           g_msg->WarnAddInfo(WARN_BUG, "Grain ", a_grain);
           g_msg->WarnAddInfo(WARN_BUG, "******** ", 0);
       }
       //**** END ****/
           
           
           return MaxRate;
   }

References AdjustIntakeRateToSnowDepth(), TMaxIntakeSource::m_instubble, TMaxIntakeSource::m_iscereal, TMaxIntakeSource::m_maxintakesource, m_MaxIntakeSource, TMaxIntakeSource::m_prevsowncrop, TMaxIntakeSource::m_veg, tomis_foobar, tomis_grain, tomis_grass, tomis_maize, and tomis_sowncrop.

Referenced by st_ChooseForageLocation(), and st_Forage().

GetMaxIntakeRate()

double Goose_Base::GetMaxIntakeRate ( double  a_grain, double  a_maize, double  a_grass  )

inline

Returns the max intake rate of the three different types of intake.

Parameters

[in]	a_grain	The intake rate from the grain resource kJ/min
[in]	a_maize	The intake rate from the maize resource kJ/min
[in]	a_grass	The intake rate from the grazing resource kJ/min

Returns

The max intake rate kJ/min

                                                                            {
       double MaxRate = 0.0;
       if (a_grain > MaxRate) {
           MaxRate = a_grain;
       }
       if (a_maize > MaxRate) {
           MaxRate = a_maize;
       }
       if (a_grass > MaxRate) {
           MaxRate = a_grass;
       }
       return MaxRate;
   }

Referenced by EvaluateForageToHopLoc(), and st_ChooseForageLocation().

GetMaxIntakeSource()

TMaxIntakeSource Goose_Base::GetMaxIntakeSource ( )

inline

Supply the current max intake source.

                                         {
       return m_MaxIntakeSource;
   }

References m_MaxIntakeSource.

Referenced by Goose_Population_Manager::DoLast().

GetRoost()

APoint Goose_Base::GetRoost ( )

inline

Supply roost coords.

{ return m_MyRoost; }

References m_MyRoost.

Referenced by Goose_Population_Manager::GetLeader().

GetRoostLeaveTime()

double Goose_Base::GetRoostLeaveTime ( )

inline

Returns the time when the goose leaves the roost.

{ return m_LeaveRoostTime; }

References m_LeaveRoostTime.

GetSex()

bool Goose_Base::GetSex ( )

inline

Returns the sex.

{ return m_sex; }

References m_sex.

GetSpecies()

GooseSpecies Goose_Base::GetSpecies ( )

inline

Returns the species.

                             {
       return m_myspecies;
   }

References m_myspecies.

Referenced by Goose_Population_Manager::DoLast().

GetTotalWeight()

double Goose_Base::GetTotalWeight ( )

inline

Returns the weight of the bird.

{return m_weightTotal;}

References m_weightTotal.

Init()

void Goose_Base::Init	(	Goose_Population_Manager *	p_NPM,
		double	a_weight,
		bool	a_sex,
		APoint	a_roost
	)

Intitialise object.

Assigns the pointer to the population manager.

Sets the initial state.

Sets the sex.

Sets the weight.

Todo:

Quick fix for spring migration weights

Calculates BMR

                                                                                                  {
    m_OurPopulationManager = p_NPM;
    CurrentGState = togs_InitialState;
    SetSex(a_sex);
    m_weight = a_weight;
    m_DailyMaxAppetite = 0.0;
    m_DailyMaxAppetiteHitTime = 0;
    m_energyReserve = m_weight * cfg_goose_InitialEnergyReserveProportion.value(); 
    int today = m_OurLandscape->SupplyDayInYear();
    if ((today >= cfg_goose_pf_springmigdatestart.value()) && (today <= cfg_goose_pf_springmigdateend.value())) {
        m_energyReserve = m_weight * 0.22; 
    }
    m_weightTotal = m_weight + m_energyReserve;
    m_BMR = pow(m_weightTotal / 1000, cfg_goose_BMRconstant2.value())*cfg_goose_BMRconstant1.value(); // BMR is used to scale other energetic costs on a daily basis
    m_energyToday = 0.0;
    m_BodyConditionCounter = 0;
    m_TheBodyCondition = 0.0;
    for (unsigned i = 0; i < 5; i++)
    {
        double condition = m_weightTotal / m_weight; // total weight divided by lean weight.
        SetBodyCondition(condition, i);
        AddBodyCondition(m_BodyCondition[i]);
    }
    m_LeaveRoostTime = 0; // intialisation
    m_myForageIndex = -1; // -1 signals not currently foraging
    m_MaxIntakeSource.m_maxintakesource = tomis_foobar;  // The source of the max forage intake rate has not been determined yet.
    // Assume a default groupsize of 1, if otherwise it needs setting in descendent classes
    m_groupsize = 1;
    // Set the roost and location
    m_Location_x = a_roost.m_x;
    m_Location_y = a_roost.m_y;
    m_MyRoost.m_x = a_roost.m_x;
    m_MyRoost.m_y = a_roost.m_y;
 
    // Any other intialisation will be done by descendent class constructors
    m_MyMemory = new GooseMemoryMap(this);
    // the species must be reset by the goose constructor
    m_myspecies = gs_foobar;
    // Must calculate the DEB now or risk use of an undefined m_DEB in StartDay
    m_DEB = 0;
    // Set the individual minimum forage rate acceptable. Overwritten later in StartDay
    Set_Indivmingooseforagerate(0.0);
    m_FlightNumber = 0;
    m_FlightDistance = 0;
    m_forageLocCount = 0;
}

References cfg_goose_BMRconstant1, cfg_goose_BMRconstant2, cfg_goose_InitialEnergyReserveProportion, cfg_goose_pf_springmigdateend, cfg_goose_pf_springmigdatestart, APoint::m_x, APoint::m_y, togs_InitialState, tomis_foobar, CfgInt::value(), and CfgFloat::value().

Referenced by Goose_Base(), Goose_Barnacle_Base::Init(), Goose_Greylag_Base::Init(), Goose_Pinkfoot_Base::Init(), and ReInit().

KillThis()

void Goose_Base::KillThis ( void  )

virtual

The bird is dead of some external cause.

Kill this for single animal agents is straightforward. We need to remove the bird from the forage area if any.

Reimplemented from TAnimal.

Reimplemented in Goose_Pinkfoot_FamilyGroup, Goose_Greylag_FamilyGroup, and Goose_Barnacle_FamilyGroup.

{
    if (m_myForageIndex != -1)
    {
        m_OurPopulationManager->RemoveGeeseFromForageLocation(m_myGooseSpeciesType, m_myForageIndex, 1);
    }
    TAnimal::KillThis(); // Sets CurrentStateNo to -1, and StepDone to true
}

References TAnimal::KillThis(), m_myForageIndex, m_myGooseSpeciesType, m_OurPopulationManager, and Goose_Population_Manager::RemoveGeeseFromForageLocation().

On_Bang() [1/2]

void Goose_Base::On_Bang

(

int

a_polyid

)

The goose is scared by a bang at location.

The goose has heard a shot. It remembers the location the shot came from as bad and flies away to find another place to forage. This version assumes the scare value is a constant 1.0. The first test is because the shot might have killed it already!

Parameters

[in]

a_polyid

The polygon id from where the shot was fired.

We have been scared off, so we the correct number of geese at that location before we fly off to find a new forage location

{ 
    if (m_CurrentStateNo == -1) return;
    if (!m_MyMemory->ChangeAddThreat(a_polyid, 1.0))
    {
        GooseMemoryLocation aThought;
        aThought.m_polygonid = a_polyid;
        aThought.m_x = m_OurLandscape->SupplyCentroidX(a_polyid);
        aThought.m_y = m_OurLandscape->SupplyCentroidY(a_polyid);
        aThought.m_threat = 1;
        int dist = g_AlmassMathFuncs.CalcDistPythagorasApprox( m_MyRoost.m_x, m_MyRoost.m_y, aThought.m_x, aThought.m_y );
        aThought.m_score = m_MyMemory->CalcScore( dist, aThought.m_foodresource, aThought.m_threat );
        m_MyMemory->MemAdd(aThought);
    }
    if (m_myForageIndex != -1)
    {
        m_OurPopulationManager->RemoveGeeseFromForageLocation(m_myGooseSpeciesType, m_myForageIndex, m_groupsize);
    }
    m_myForageIndex = -1;
    CurrentGState = st_ChooseForageLocation();
}

References ALMaSS_MathFuncs::CalcDistPythagorasApprox(), GooseMemoryMap::CalcScore(), GooseMemoryMap::ChangeAddThreat(), CurrentGState, g_AlmassMathFuncs, TALMaSSObject::m_CurrentStateNo, GooseMemoryLocation::m_foodresource, m_groupsize, m_myForageIndex, m_myGooseSpeciesType, m_MyMemory, m_MyRoost, TAnimal::m_OurLandscape, m_OurPopulationManager, GooseMemoryLocation::m_polygonid, GooseMemoryLocation::m_score, GooseMemoryLocation::m_threat, APoint::m_x, GooseMemoryLocation::m_x, APoint::m_y, GooseMemoryLocation::m_y, GooseMemoryMap::MemAdd(), Goose_Population_Manager::RemoveGeeseFromForageLocation(), st_ChooseForageLocation(), Landscape::SupplyCentroidX(), and Landscape::SupplyCentroidY().

Referenced by Goose_Population_Manager::BangAtPoly().

On_Bang() [2/2]

void Goose_Base::On_Bang	(	int	a_polyid,
		double	a_scare
	)

The goose is scared by a bang at location.

The goose has heard a shot. It remembers the location the shot came from as bad and flies away to find another place to forage. This version allows a variable scare value to be remembered. The first test is because the shot might have killed it already!

Parameters

[in]	a_polyid	The polygon id from where the shot was fired.
[in]	a_scare	The scare value.

We have been scared off, so we the correct number of geese at that location before we fly off to find a new forage location

{ 
    if (m_CurrentStateNo == -1) return;
    if (!m_MyMemory->ChangeAddThreat(a_polyid, a_scare))
    {
        GooseMemoryLocation aThought;
        aThought.m_polygonid = a_polyid;
        aThought.m_x = m_OurLandscape->SupplyCentroidX(a_polyid);
        aThought.m_y = m_OurLandscape->SupplyCentroidY(a_polyid);
        aThought.m_threat = a_scare;
        int dist = g_AlmassMathFuncs.CalcDistPythagorasApprox( m_MyRoost.m_x, m_MyRoost.m_y, aThought.m_x, aThought.m_y );
        aThought.m_score = m_MyMemory->CalcScore( dist, aThought.m_foodresource, aThought.m_threat );
        m_MyMemory->MemAdd(aThought);
    }
    if (m_myForageIndex != -1)
    {
        m_OurPopulationManager->RemoveGeeseFromForageLocation(m_myGooseSpeciesType, m_myForageIndex, m_groupsize);
    }
    m_myForageIndex = -1;
    CurrentGState = st_ChooseForageLocation();
}

References ALMaSS_MathFuncs::CalcDistPythagorasApprox(), GooseMemoryMap::CalcScore(), GooseMemoryMap::ChangeAddThreat(), CurrentGState, g_AlmassMathFuncs, TALMaSSObject::m_CurrentStateNo, GooseMemoryLocation::m_foodresource, m_groupsize, m_myForageIndex, m_myGooseSpeciesType, m_MyMemory, m_MyRoost, TAnimal::m_OurLandscape, m_OurPopulationManager, GooseMemoryLocation::m_polygonid, GooseMemoryLocation::m_score, GooseMemoryLocation::m_threat, APoint::m_x, GooseMemoryLocation::m_x, APoint::m_y, GooseMemoryLocation::m_y, GooseMemoryMap::MemAdd(), Goose_Population_Manager::RemoveGeeseFromForageLocation(), st_ChooseForageLocation(), Landscape::SupplyCentroidX(), and Landscape::SupplyCentroidY().

On_Emigrate()

virtual void Goose_Base::On_Emigrate ( )

inlinevirtual

Cause the bird to immediately transition to Emigrate.

   {
       CurrentGState = togs_Emigrate; 
   }

References CurrentGState, and togs_Emigrate.

On_Migrate()

void Goose_Base::On_Migrate

(

TTypeOfLeaveReason

a_leavereason

)

The goose is told to leave the simulation area (poss due to bad weather)

We need to migrate out of the simulation and record the reason for leaving. This is currently done by killing the bird. No birds are migrating back into the simulation.

Parameters

[in]

a_leavereason

The reason for leaving. One of the values in the enum TTypeOfLeaveReason.

{
    CurrentGState = togs_Die;
    m_OurPopulationManager->RecordLeaveReason(a_leavereason, m_myGooseSpeciesType);
}

References CurrentGState, m_myGooseSpeciesType, m_OurPopulationManager, Goose_Population_Manager::RecordLeaveReason(), and togs_Die.

Referenced by StartDay(), Goose_Barnacle_FamilyGroup::Step(), Goose_Barnacle_NonBreeder::Step(), Goose_Greylag_FamilyGroup::Step(), Goose_Greylag_NonBreeder::Step(), Goose_Pinkfoot_FamilyGroup::Step(), and Goose_Pinkfoot_NonBreeder::Step().

On_MoveTo()

void Goose_Base::On_MoveTo ( int  a_x, int  a_y  )

inline

The goose is moved to the location specified by a_x, a_y - caused by group decision.

{ FlyTo( a_x, a_y); }

References FlyTo().

ReInit()

void Goose_Base::ReInit	(	Landscape *	p_L,
		Goose_Population_Manager *	p_NPM,
		double	a_weight,
		bool	a_sex,
		APoint	a_roost
	)

ReInit for object pool.

                                                                                                                    {
    TAnimal::ReinitialiseObject(0, 0, p_L);
    // Assign the pointer to the population manager
    Init(p_NPM, a_weight, a_sex, a_roost);
}

References Init(), and TALMaSSObject::ReinitialiseObject().

Referenced by Goose_Barnacle_Base::ReInit(), Goose_Greylag_Base::ReInit(), and Goose_Pinkfoot_Base::ReInit().

ScaleForageToGroupsize()

double Goose_Base::ScaleForageToGroupsize ( double  a_forage )

inline

Scales forage to groupsize.

{ return m_groupsize * a_forage; }

References m_groupsize.

Referenced by st_Forage().

Set_GooseFattoKJConversion()

void Goose_Base::Set_GooseFattoKJConversion ( double  a_cost )

inline

Set the fat to kJ conversion constant for all geese.

{ m_GooseFattoKJConversion = a_cost; }

References m_GooseFattoKJConversion.

Referenced by Goose_Population_Manager::Goose_Population_Manager().

Set_GooseFieldForageDist()

void Goose_Base::Set_GooseFieldForageDist ( double  sp1, double  sp2, double  sp3  )

inline

Set the max forage distance from a field for all geese.

   {
       //Dist
       m_GooseFieldForageDist[gs_Pinkfoot] = sp1;
       m_GooseFieldForageDist[gs_Barnacle] = sp2;
       m_GooseFieldForageDist[gs_Greylag] = sp3;
       // DistX2
       m_GooseFieldForageDistX2[gs_Pinkfoot] = sp1 * 2.0;
       m_GooseFieldForageDistX2[gs_Barnacle] = sp2 * 2.0;
       m_GooseFieldForageDistX2[gs_Greylag] = sp3 * 2.0;
   }

References m_GooseFieldForageDist, and m_GooseFieldForageDistX2.

Referenced by Goose_Population_Manager::Goose_Population_Manager().

Set_GooseFollowingLikelyhood()

void Goose_Base::Set_GooseFollowingLikelyhood ( int  a_likelyhood, GooseSpeciesType  a_speciestype  )

inline

Set the followinglikelyhood.

{ m_followinglikelyhood[a_speciestype] = a_likelyhood;}

References m_followinglikelyhood.

Referenced by Goose_Population_Manager::Goose_Population_Manager().

Set_GooseForageDist()

void Goose_Base::Set_GooseForageDist ( double  sp1, double  sp2, double  sp3  )

inline

Set the max forage distance from roost for all geese.

   { 
       //Dist
       m_GooseForageDist[gs_Pinkfoot] = sp1;
       m_GooseForageDist[gs_Barnacle] = sp2;
       m_GooseForageDist[gs_Greylag] = sp3;
       // DistX2
       m_GooseForageDistX2[gs_Pinkfoot] = sp1 * 2.0;
       m_GooseForageDistX2[gs_Barnacle] = sp2 * 2.0;
       m_GooseForageDistX2[gs_Greylag] = sp3 * 2.0;
   }

References m_GooseForageDist, and m_GooseForageDistX2.

Referenced by Goose_Population_Manager::Goose_Population_Manager().

Set_GooseKJtoFatConversion()

void Goose_Base::Set_GooseKJtoFatConversion ( double  a_cost )

inline

Set the kJ to fat conversion constant for all geese.

{ m_GooseKJtoFatConversion = a_cost; }

References m_GooseKJtoFatConversion.

Referenced by Goose_Population_Manager::Goose_Population_Manager().

Set_GooseLeavingRoost()

void Goose_Base::Set_GooseLeavingRoost ( bool  a_leaving )

inline

Set the flag to indicate if we are coming from the roost.

{m_LeavingRoost = a_leaving;}

References m_LeavingRoost.

Referenced by Goose_Population_Manager::Goose_Population_Manager(), st_ChooseForageLocation(), and st_Roost().

Set_GooseLeavingThreshold()

void Goose_Base::Set_GooseLeavingThreshold ( double  a_threshold )

inline

Set the body condition threshold for leaving for all geese.

{ m_GooseLeavingThreshold = a_threshold; }

References m_GooseLeavingThreshold.

Referenced by Goose_Population_Manager::Goose_Population_Manager().

Set_GooseMaxAppetiteScaler()

void Goose_Base::Set_GooseMaxAppetiteScaler ( double  a_cost )

inline

Set the goose appetite scale used to calculate max intake for all geese.

{ m_GooseMaxAppetiteScaler = a_cost; }

References m_GooseMaxAppetiteScaler.

Referenced by Goose_Population_Manager::Goose_Population_Manager().

Set_GooseMaxEnergyReserveProportion()

void Goose_Base::Set_GooseMaxEnergyReserveProportion ( double  a_prop )

inline

Set the maximum energy reserve proportion allowed for all geese.

{ m_GooseMaxEnergyReserveProportion = a_prop; }

References m_GooseMaxEnergyReserveProportion.

Referenced by Goose_Population_Manager::Goose_Population_Manager().

Set_GooseMinForageOpenness()

void Goose_Base::Set_GooseMinForageOpenness ( double  a_cost )

inline

Set the min forage openess for all geese.

{ m_GooseMinForageOpenness = a_cost; }

References m_GooseMinForageOpenness.

Referenced by Goose_Population_Manager::Goose_Population_Manager().

Set_Indivmingooseforagerate()

void Goose_Base::Set_Indivmingooseforagerate ( double  a_cost )

inline

Set the mimimum tolerated forage rate for the individual goose.

                                                    {
       m_Indivmingooseforagerate = a_cost;
   }

References m_Indivmingooseforagerate.

Referenced by Goose_Population_Manager::Goose_Population_Manager(), st_Forage(), and StartDay().

Set_mingooseforagerate()

void Goose_Base::Set_mingooseforagerate ( double  a_cost, GooseSpecies  a_species  )

inline

Set the mimimum tolerated forage rate for all geese.

{ m_mingooseforagerate[a_species] = a_cost; }

References m_mingooseforagerate.

Referenced by Goose_Population_Manager::Goose_Population_Manager(), and StartDay().

SetBodyCondition()

void Goose_Base::SetBodyCondition ( double  a_condition, unsigned  a_index  )

inline

Sets the current body condition.

{ m_BodyCondition[a_index] = a_condition; }

References m_BodyCondition.

Referenced by StartDay().

SetFlightCost()

void Goose_Base::SetFlightCost ( double  a_cost )

inline

Set the flight cost per m per g.

{ m_flightcost = a_cost; }

References m_flightcost.

Referenced by Goose_Population_Manager::Goose_Population_Manager().

SetSex()

void Goose_Base::SetSex ( bool  a_sex )

inline

Sets the sex.

                             {
       m_sex = a_sex;
   }

References m_sex.

st_ChooseForageLocation()

TTypeOfGoose_BaseState Goose_Base::st_ChooseForageLocation ( void  )

protected

Selects a forage location based on past memory, or initiates an exploration.

1. If we are following then find a good location from the main list of birds held by the population manager. If no such location is available then default to explore.

Depending on the rules in force we probably only want to follow geese from our own species, and maybe from our own roost

First searches memory for the best forage location remembered. If it finds one then it flies there and calculates the energetic cost. If no suitable memory is found then initiates an exploration.

Once the goose arrives at a forage location it needs to add itself to the geese already there, or initiate a forage location if one does not exist.

{
    // Debugging
    m_OurPopulationManager->RecordState();
    int today = m_OurLandscape->SupplyDayInYear();
    int dtime = m_OurPopulationManager->GetDayTime();
    int daylength = m_OurLandscape->SupplyDaylength();
    if (dtime >= daylength + cfg_goose_AfterDarkTime.value())
    {
#ifdef __DEBUG_GOOSE
        if (m_myForageIndex != -1)
        {
            if (m_OurPopulationManager->GetBirdsAtForageLoc(m_myForageIndex, m_myGooseSpeciesType) < m_groupsize) {
                g_msg->Warn("Goose_Base::st_ChooseForageLocation - Removing negative geese from forage location", (double)(m_OurPopulationManager->GetBirdsAtForageLoc(m_myForageIndex, m_myGooseSpeciesType) - m_groupsize));
                exit(0);
            }
        }
#endif
        return togs_ToRoost;
    }
 
    if (g_rand_uni2() <= m_followinglikelyhood[m_myGooseSpeciesType])
    {
#ifdef __FOLLOW_FIELD
        int index = -1;
            int forageindex = m_OurPopulationManager->GetForageLocIndex( m_myspecies, m_Location_x, m_Location_y );
            if (forageindex > -1) {
                index = forageindex;
            }
#endif
 
#ifdef __FOLLOW_BIRD  
        Goose_Base* leader = m_OurPopulationManager->GetLeader( m_MyRoost, m_myspecies );
        if (leader != NULL) {
            int index = leader->GetForageLocIndex();
    }
#endif
 
            if (index > -1) 
            {
 
                GooseActiveForageLocation* gafl = m_OurPopulationManager->GetForageLocation( index );
                FlyTo( m_OurLandscape->SupplyCentroid( gafl->GetPolygonref() ) );
                Set_GooseLeavingRoost(false);  // We've left the roost now, so reset
                GooseMemoryLocation aThought;
                int poly = gafl->GetPolygonref();
                double grain = gafl->GetGrainDensity();  // grain/m2
                double maize = gafl->GetMaizeDensity();  // kJ/m2
                aThought.m_grain = m_OurPopulationManager->GetFeedingRate(grain, m_myspecies);  // kJ/min
                aThought.m_maize = m_OurPopulationManager->GetMaizeFeedingRate(maize, m_myspecies);  // kJ/min
                aThought.m_grazing = gafl->GetGrazing( (int)m_myspecies );  // kJ/min
                aThought.m_foodresource = GetMaxIntakeRate(aThought.m_grain, aThought.m_maize, aThought.m_grazing);
                aThought.m_polygonid = poly;
                aThought.m_x = m_OurLandscape->SupplyCentroidX( poly );
                aThought.m_y = m_OurLandscape->SupplyCentroidY( poly );
                aThought.m_threat = 0;
                int dist = g_AlmassMathFuncs.CalcDistPythagorasApprox( m_MyRoost.m_x, m_MyRoost.m_y, aThought.m_x, aThought.m_y );
                aThought.m_score = m_MyMemory->CalcScore(dist, aThought.m_foodresource, aThought.m_threat);
                if (!m_MyMemory->IsKnownArea( gafl->GetPolygonref() )) m_MyMemory->MemAdd( aThought );
                // Once the goose arrives at a forage location it needs to add itself to the geese already there, or initiate a forage location if one does not exist 
                m_myForageIndex = m_OurPopulationManager->ForageLocationInUse( aThought.m_polygonid );
                if (m_myForageIndex != -1) m_OurPopulationManager->AddGeeseToForageLocation( m_myGooseSpeciesType, m_myForageIndex, m_groupsize );
                else {
                    g_msg->Warn( "TTypeOfGoose_BaseState Goose_Base::st_ChooseForageLocation() : No geese at foraging location when following", "" );
                    exit( 0 );
                }
                // some stats recording
                m_forageLocCount++;
                m_myMemPolyID = aThought.m_polygonid;
                return togs_Forage;
            }
    }
    if (m_LeavingRoost) Explore();  // Go for an exploration trip to initialise the memory.
    GooseMemoryLocation aThought = m_MyMemory->GetBestFeedingScore();
    if (aThought.m_score<=0)
    {
        Explore();  // Go for an exploration trip
        aThought = m_MyMemory->GetBestFeedingScore();
        // Did we find anything suitable?:
        if (aThought.m_score <= 0) {
            // if not, start this method over again.
            return togs_ChooseForageLocation;
        }
    }
    m_Location_x = aThought.m_x;
    m_Location_y = aThought.m_y;
    int polyref = m_OurLandscape->SupplyPolyRef(m_Location_x, m_Location_y);
    double grazing = m_OurLandscape->GetActualGooseGrazingForage(polyref, m_myspecies);  // kJ/min
    double grain = m_OurLandscape->SupplyBirdSeedForage(polyref);  // kJ/m2
    double maize = m_OurLandscape->SupplyBirdMaizeForage(polyref);  // kJ/m2
    bool instubble = m_OurLandscape->SupplyInStubble(polyref);
    TTypesOfVegetation veg = m_OurLandscape->SupplyVegType(polyref);
    TTypesOfVegetation lastsowncrop = m_OurLandscape->SupplyLastSownVeg(polyref);
    bool iscereal = m_OurLandscape->SupplyIsCereal2(lastsowncrop);
    // Here we make a test to see if the forage location is in use before going further
    m_myForageIndex = m_OurPopulationManager->ForageLocationInUse(aThought.m_polygonid);
    // Here we do the forage calculation.The intake rate depends on :
    // -1 The grain or grazing resource available in grain and grazing
    double grain_intake = m_OurPopulationManager->GetFeedingRate(grain, m_myspecies); // kJ/min
    double maize_intake = m_OurPopulationManager->GetMaizeFeedingRate(maize, m_myspecies); // kJ/min
    m_MyMemory->ChangeSetFoodRes(aThought.m_polygonid, grain_intake, maize_intake, grazing);  // Remember these
// -2 The relationship between resource and intake rate.This is dependent on the species and family or non - breeder. It also depends on the 
    // type of resource, i.e. the response for grain is different than for grazing.
    // -3 The number of geese which will determine an interference competition factor, which reduces intake rate
    double geese = m_groupsize;  // if m_myForageIndex = -1, nobody else is there.
    if ( m_myForageIndex != -1) geese = m_OurPopulationManager->GetForageGooseDensity(m_myForageIndex);
    // -4 The interference factor is a look-up from a pre-calculated curve in the goose population manager
    double interferenceComp = m_OurPopulationManager->GetForageRateDensity(geese);
    // A simplification here is to assume that they either eat grain or graze but not both
    double myforagerate;
    myforagerate = GetMaxForageRate( grain_intake, maize_intake, grazing, interferenceComp, iscereal, veg, instubble, lastsowncrop);  // GetMaxForageRate determines the source of max intake rate and adjust intake for snow cover if needed.
    // Now decide if this is OK or not. The intake rate is compared to the current minimum intake rate for the individual.
    if (myforagerate < m_Indivmingooseforagerate)
    {
        m_myForageIndex = -1; // If we don't do this we will get a negative number of geese on the forage location later unless they find somewhere else to go.
        return togs_ChooseForageLocation;
    }
    // OK we are staying
    m_forageLocCount++;
    if (m_myForageIndex != -1){
        m_OurPopulationManager->AddGeeseToForageLocation(m_myGooseSpeciesType, m_myForageIndex, m_groupsize);
    }
    else {
        m_myForageIndex = m_OurPopulationManager->NewForageLocation(m_myGooseSpeciesType, m_groupsize, aThought.m_polygonid);
    }
    m_myMemPolyID = aThought.m_polygonid;
    return togs_Forage;
}

References Goose_Population_Manager::AddGeeseToForageLocation(), ALMaSS_MathFuncs::CalcDistPythagorasApprox(), GooseMemoryMap::CalcScore(), cfg_goose_AfterDarkTime, GooseMemoryMap::ChangeSetFoodRes(), Explore(), FlyTo(), Goose_Population_Manager::ForageLocationInUse(), g_AlmassMathFuncs, g_msg, g_rand_uni2, Landscape::GetActualGooseGrazingForage(), GooseMemoryMap::GetBestFeedingScore(), Goose_Population_Manager::GetBirdsAtForageLoc(), Goose_Population_Manager::GetDayTime(), Goose_Population_Manager::GetFeedingRate(), Goose_Population_Manager::GetForageGooseDensity(), Goose_Population_Manager::GetForageLocation(), GetForageLocIndex(), Goose_Population_Manager::GetForageLocIndex(), Goose_Population_Manager::GetForageRateDensity(), GooseActiveForageLocation::GetGrainDensity(), GooseActiveForageLocation::GetGrazing(), Goose_Population_Manager::GetLeader(), GooseActiveForageLocation::GetMaizeDensity(), Goose_Population_Manager::GetMaizeFeedingRate(), GetMaxForageRate(), GetMaxIntakeRate(), GooseActiveForageLocation::GetPolygonref(), GooseMemoryMap::IsKnownArea(), m_followinglikelyhood, GooseMemoryLocation::m_foodresource, m_forageLocCount, GooseMemoryLocation::m_grain, GooseMemoryLocation::m_grazing, m_groupsize, m_Indivmingooseforagerate, m_LeavingRoost, TAnimal::m_Location_x, TAnimal::m_Location_y, GooseMemoryLocation::m_maize, m_myForageIndex, m_myGooseSpeciesType, m_MyMemory, m_myMemPolyID, m_MyRoost, m_myspecies, TAnimal::m_OurLandscape, m_OurPopulationManager, GooseMemoryLocation::m_polygonid, GooseMemoryLocation::m_score, GooseMemoryLocation::m_threat, APoint::m_x, GooseMemoryLocation::m_x, APoint::m_y, GooseMemoryLocation::m_y, GooseMemoryMap::MemAdd(), Goose_Population_Manager::NewForageLocation(), Goose_Population_Manager::RecordState(), Set_GooseLeavingRoost(), Landscape::SupplyBirdMaizeForage(), Landscape::SupplyBirdSeedForage(), Landscape::SupplyCentroid(), Landscape::SupplyCentroidX(), Landscape::SupplyCentroidY(), Landscape::SupplyDayInYear(), Landscape::SupplyDaylength(), Landscape::SupplyInStubble(), Landscape::SupplyIsCereal2(), Landscape::SupplyLastSownVeg(), Landscape::SupplyPolyRef(), Landscape::SupplyVegType(), togs_ChooseForageLocation, togs_Forage, togs_ToRoost, CfgInt::value(), and MapErrorMsg::Warn().

Referenced by On_Bang(), Goose_Barnacle_FamilyGroup::Step(), Goose_Barnacle_NonBreeder::Step(), Goose_Greylag_FamilyGroup::Step(), Goose_Greylag_NonBreeder::Step(), Goose_Pinkfoot_FamilyGroup::Step(), and Goose_Pinkfoot_NonBreeder::Step().

st_Dying()

void Goose_Base::st_Dying

(

void

)

Behavioural state dying.

{
    m_CurrentStateNo = -1; // this will kill the animal object and free up space
    m_StepDone = true;
    delete m_MyMemory; // this is reinitisalised in the object pool.
}

References TALMaSSObject::m_CurrentStateNo, m_MyMemory, and TALMaSSObject::m_StepDone.

Referenced by Goose_Barnacle_FamilyGroup::Step(), Goose_Barnacle_NonBreeder::Step(), Goose_Greylag_FamilyGroup::Step(), Goose_Greylag_NonBreeder::Step(), Goose_Pinkfoot_FamilyGroup::Step(), and Goose_Pinkfoot_NonBreeder::Step().

st_Forage()

TTypeOfGoose_BaseState Goose_Base::st_Forage

(

)

Behavioural forage.

Must assess the competition status here (must be at a forage location to call this state). If the forage rate resulting from competition and forage availability is too low then the bird will move the flock/family, otherwise it will signal feeding at a certain rate. The forage loss will need to be calculated and sent to the LE polygon (foragae location) in question. This is done immediately since it will influence the forage assessment of birds not yet considered in this step (assumed to come later).

The first things is to check if we are near the end of daylight, if so then fly to roost.

If the goose has eaten all it can in a day, then it just rests on the field until evening.
Get the grain and forage density - NB is in KJ, which needs to be to needs to be remembered.
Here we do the forage calculation.The intake rate depends on : -1 The grain or grazing resource available -2 The relationship between resource and intake rate.This is dependent on the species and family or non - breeder. It also depends on the type of resource, i.e. the response for grain is different than for grazing. -3 The number of geese which will determine an interference competition factor, which reduces intake rate

Then decide if this is OK or not. The simplest here is to compare to a standard intake rate threshold for the species/type combination.

If can't get our required forage rate then try to find somewhere that we can, and if we find a place that cannot meet our requirements then we want to forget this place fast.

No food here, so lower the acceptable level of MFR

If the goose decides to move on immediately then it must deregister itself or group with the population manager at this forage location. This is done by using RemoveGeeseFromForageLocation

If OK then how long should we feed?
There are three constraints:

• End of day
• Crop full
• Energy reserves a maximum

{
    int dtime = m_OurPopulationManager->GetDayTime();
    int daylength = m_OurLandscape->SupplyDaylength();
    if (dtime >= daylength + cfg_goose_AfterDarkTime.value())
    {
#ifdef __DEBUG_GOOSE
        if (m_myForageIndex != -1)
        {
            if (m_OurPopulationManager->GetBirdsAtForageLoc(m_myForageIndex, m_myGooseSpeciesType) < m_groupsize) {
                g_msg->Warn("Goose_Base::st_Forage - Removing negative geese from forage location", (double)(m_OurPopulationManager->GetBirdsAtForageLoc(m_myForageIndex, m_myGooseSpeciesType) - m_groupsize));
                exit(0);
            }
        }
#endif
        return togs_ToRoost;
    }
    if (m_energyToday >= m_DailyMaxAppetite)
    {
        if (m_DailyMaxAppetiteHitTime > dtime) {
            m_DailyMaxAppetiteHitTime = dtime;
        }
        return togs_Forage;  
    }
    //
    // Get the grain and forage density - NB grain/m2 and maize in kJ/m2, which needs to be to needs to be remembered.
    //
    int polyref = m_OurPopulationManager->m_GooseForageLocations[m_myForageIndex].GetPolygonref();
    double grazing = m_OurLandscape->GetActualGooseGrazingForage(polyref, m_myspecies);  // kJ/min
    double grain = m_OurLandscape->SupplyBirdSeedForage(polyref);  // kJ/m2
    double maize = m_OurLandscape->SupplyBirdMaizeForage(polyref);  // kJ/m2
    bool instubble = m_OurLandscape->SupplyInStubble(polyref);
    TTypesOfVegetation veg = m_OurLandscape->SupplyVegType(polyref);
    TTypesOfVegetation lastsowncrop = m_OurLandscape->SupplyLastSownVeg(polyref);
    bool iscereal = m_OurLandscape->SupplyIsCereal2(lastsowncrop);
    // Here we do the forage calculation.The intake rate depends on :
    // -1 The grain, maize or grazing resource available in grain, maize and grazing
    double grain_intake = m_OurPopulationManager->GetFeedingRate( grain, m_myspecies ); // KJ/min
    double maize_intake = m_OurPopulationManager->GetMaizeFeedingRate(maize, m_myspecies); // KJ/min
    m_MyMemory->ChangeSetFoodRes(m_myMemPolyID, grain_intake, maize_intake, grazing);  // Remember these
    // -2 The relationship between resource and intake rate. This is dependent on the species and family or non-breeder. It also depends on the 
    // type of resource, i.e. the response for grain or maize is different than for grazing.
    // -3 The number of geese which will determine an interference competition factor, which reduces intake rate
    double geese = m_OurPopulationManager->GetForageGooseDensity(m_myForageIndex);
    // -4 The interfence factor is a look-up from a pre-calculated curve in the goose population manager
    double interferenceComp = m_OurPopulationManager->GetForageRateDensity(geese);
    // A simplification here is to assume that they either eat grain, maize or graze but any combination
    double myforagerate;
    myforagerate = GetMaxForageRate( grain_intake, maize_intake, grazing, interferenceComp, iscereal, veg, instubble, lastsowncrop);  // GetMaxForageRate determines the source of max intake rate and adjust intake for snow cover if needed.
    // Now decide if this is OK or not. The simplest here is to compare to a standard intake rate threshold for the species/type combination.
    if (myforagerate < m_Indivmingooseforagerate)
    {
        m_MyMemory->MemDel(m_myMemPolyID);
        Set_Indivmingooseforagerate( m_Indivmingooseforagerate * cfg_goose_MinForageRateDecayRate.value() );   
        
        m_OurPopulationManager->RemoveGeeseFromForageLocation(m_myGooseSpeciesType, m_myForageIndex, m_groupsize);
        m_myForageIndex = -1; 
        return togs_ChooseForageLocation;
    }
    // We have lots of food, stay and eat until full.
    double forage = myforagerate * 10; // 10 for 10 minutes
    m_energyToday += forage; 
    // Scale the amount of forage removed from the field to the size of the group (1 for non-breeders)
    forage = ScaleForageToGroupsize(forage);
    m_OurPopulationManager->RemoveMaxForageKj( forage, m_MaxIntakeSource.m_maxintakesource, m_myForageIndex );  // Removes kJ from the field 
    if (dtime >= daylength + cfg_goose_AfterDarkTime.value())
    {
        Set_Indivmingooseforagerate( GetGooseMinForageRate(m_myspecies) );  // Okay, we found food today, so reset the minimum acceptable MFR.
        return togs_ToRoost;
    }
    return togs_Forage;
}

References cfg_goose_AfterDarkTime, cfg_goose_MinForageRateDecayRate, GooseMemoryMap::ChangeSetFoodRes(), g_msg, Landscape::GetActualGooseGrazingForage(), Goose_Population_Manager::GetBirdsAtForageLoc(), Goose_Population_Manager::GetDayTime(), Goose_Population_Manager::GetFeedingRate(), Goose_Population_Manager::GetForageGooseDensity(), Goose_Population_Manager::GetForageRateDensity(), GetGooseMinForageRate(), Goose_Population_Manager::GetMaizeFeedingRate(), GetMaxForageRate(), m_DailyMaxAppetite, m_DailyMaxAppetiteHitTime, m_energyToday, Goose_Population_Manager::m_GooseForageLocations, m_groupsize, m_Indivmingooseforagerate, TMaxIntakeSource::m_maxintakesource, m_MaxIntakeSource, m_myForageIndex, m_myGooseSpeciesType, m_MyMemory, m_myMemPolyID, m_myspecies, TAnimal::m_OurLandscape, m_OurPopulationManager, GooseMemoryMap::MemDel(), Goose_Population_Manager::RemoveGeeseFromForageLocation(), Goose_Population_Manager::RemoveMaxForageKj(), ScaleForageToGroupsize(), Set_Indivmingooseforagerate(), Landscape::SupplyBirdMaizeForage(), Landscape::SupplyBirdSeedForage(), Landscape::SupplyDaylength(), Landscape::SupplyInStubble(), Landscape::SupplyIsCereal2(), Landscape::SupplyLastSownVeg(), Landscape::SupplyVegType(), togs_ChooseForageLocation, togs_Forage, togs_ToRoost, CfgInt::value(), CfgFloat::value(), and MapErrorMsg::Warn().

Referenced by Goose_Barnacle_FamilyGroup::Step(), Goose_Barnacle_NonBreeder::Step(), Goose_Greylag_FamilyGroup::Step(), Goose_Greylag_NonBreeder::Step(), Goose_Pinkfoot_FamilyGroup::Step(), and Goose_Pinkfoot_NonBreeder::Step().

st_Roost()

TTypeOfGoose_BaseState Goose_Base::st_Roost

(

)

Roosting until next forage or next morning.

Assesses whether it is daylight and time to leave the roost. If not it continues to roost.

m_LeaveRoostTime is a way to stagger the birds leaving the roost. Each birds has its own leave time set each day.

{
    if ( !m_OurPopulationManager->GetIsDaylight() )
    {
        return togs_Roost;
    }
    if (m_LeaveRoostTime > m_OurPopulationManager->GetDayTime())
    {
        return togs_Roost;
    }
    Set_GooseLeavingRoost( true );  // Indicate that we are coming from the roost. Used to trigger memory initialisation via explore.
    return togs_ChooseForageLocation;
}

References Goose_Population_Manager::GetDayTime(), Goose_Population_Manager::GetIsDaylight(), m_LeaveRoostTime, m_OurPopulationManager, Set_GooseLeavingRoost(), togs_ChooseForageLocation, and togs_Roost.

Referenced by Goose_Barnacle_FamilyGroup::Step(), Goose_Barnacle_NonBreeder::Step(), Goose_Greylag_FamilyGroup::Step(), Goose_Greylag_NonBreeder::Step(), Goose_Pinkfoot_FamilyGroup::Step(), and Goose_Pinkfoot_NonBreeder::Step().

st_ToRoost()

TTypeOfGoose_BaseState Goose_Base::st_ToRoost ( )

virtual

Return to roost and assess whether to forage again that day.

Reimplemented in Goose_Pinkfoot_Base, Goose_Greylag_Base, and Goose_Barnacle_Base.

{
    return togs_foobar;
}

References togs_foobar.

StartDay()

void Goose_Base::StartDay ( void  )

virtual

Do any 'housekeeping' associated with the start of day.

{ 
    // Adjust the energy reserves
    if (m_OurPopulationManager->GetDayTime() == 0)  
    {
        // Remove our DEB from our net energy collection for the day
        m_energyToday -= m_DEB;
        if (m_energyToday > 0)
        {
            m_energyReserve += m_energyToday * m_GooseKJtoFatConversion;
        }
        else m_energyReserve += m_energyToday * m_GooseFattoKJConversion;
        
        m_weightTotal = m_weight + m_energyReserve;
        if (m_weightTotal < m_weight) {
            On_Migrate(tolr_leanweight);
        }
        // Some goose output recording
        int foraging_time = GetForagingTime(m_DailyMaxAppetiteHitTime, m_LeaveRoostTime);
        m_OurPopulationManager->RecordForagingTime(foraging_time, m_myspecies);
        m_OurPopulationManager->RecordFlightDistance(m_FlightDistance, m_myspecies);
        m_OurPopulationManager->RecordDailyEnergyBudget(m_DEB, m_myspecies);
        m_OurPopulationManager->RecordDailyEnergyBalance(m_energyToday, m_myspecies);
        m_OurPopulationManager->RecordWeight(m_weightTotal, m_myspecies);
        m_OurPopulationManager->RecordIndForageLoc(double(m_forageLocCount), m_groupsize, m_myspecies);
        m_forageLocCount = 0;
 
        // Set the body condition as % by weight of fat. This is a running sum over the last 5 days.
        m_BodyConditionCounter = ++m_BodyConditionCounter & 5;
        SubtractBodyCondition(m_BodyCondition[m_BodyConditionCounter]);
        double condition = m_weightTotal / m_weight;
        SetBodyCondition( condition, m_BodyConditionCounter );
        AddBodyCondition( m_BodyCondition[m_BodyConditionCounter]);
        // Here we limit the maximum growth possible
        if (m_energyReserve / m_weight > m_GooseMaxEnergyReserveProportion) {
            m_energyReserve = m_GooseMaxEnergyReserveProportion *  m_weight;
        }
        if (m_TheBodyCondition < m_GooseLeavingThreshold)
        {
            On_Migrate(tolr_bodycondition);
        }
        // Reset energy intake
        m_energyToday = 0;
        m_FlightNumber = 0;
        m_FlightDistance = 0;
        // Reset the roost leaving time
        m_LeaveRoostTime = (*m_OurPopulationManager->m_variate_generator)();
        // Reset the time when m_DailyMaxAppetite was hit. If reaching dailymaxappetite takes less than a whole day, the time is recorded. Therefore we "reset" to 1440, not 0.
        m_DailyMaxAppetiteHitTime = 1440;
        // Decay all memories before adding new information today
        m_MyMemory->DecayAllMemory();
        // Calculate the new DEB
        double daylightprop = m_OurLandscape->SupplyDaylightProp();
        double nighttimeprop = m_OurLandscape->SupplyNightProp();
        double multiplier = cfg_goose_daytime_BMR_multiplier.value() * daylightprop + cfg_goose_nighttime_BMR_multiplier.value() * nighttimeprop; 
        m_DEB = m_BMR * multiplier + m_OurPopulationManager->GetThermalCosts( m_myspecies );
        double minforagerate = (m_DEB / (1440 * daylightprop));  // They accept forage rates so they can optain positive energy balance
        Set_mingooseforagerate( minforagerate, m_myspecies );
        Set_Indivmingooseforagerate( minforagerate );  // At the start of the day, give the individual the MFR for the species
        m_SnowDepth = m_OurLandscape->SupplySnowDepth();  // We store the current snow depth here for speed optimization. 
    }
} 

References AddBodyCondition(), cfg_goose_daytime_BMR_multiplier, cfg_goose_nighttime_BMR_multiplier, GooseMemoryMap::DecayAllMemory(), Goose_Population_Manager::GetDayTime(), GetForagingTime(), Goose_Population_Manager::GetThermalCosts(), m_BMR, m_BodyCondition, m_BodyConditionCounter, m_DailyMaxAppetiteHitTime, m_DEB, m_energyReserve, m_energyToday, m_FlightDistance, m_FlightNumber, m_forageLocCount, m_GooseFattoKJConversion, m_GooseKJtoFatConversion, m_GooseLeavingThreshold, m_GooseMaxEnergyReserveProportion, m_groupsize, m_LeaveRoostTime, m_MyMemory, m_myspecies, TAnimal::m_OurLandscape, m_OurPopulationManager, m_SnowDepth, m_TheBodyCondition, Goose_Population_Manager::m_variate_generator, m_weight, m_weightTotal, On_Migrate(), Goose_Population_Manager::RecordDailyEnergyBalance(), Goose_Population_Manager::RecordDailyEnergyBudget(), Goose_Population_Manager::RecordFlightDistance(), Goose_Population_Manager::RecordForagingTime(), Goose_Population_Manager::RecordIndForageLoc(), Goose_Population_Manager::RecordWeight(), Set_Indivmingooseforagerate(), Set_mingooseforagerate(), SetBodyCondition(), SubtractBodyCondition(), Landscape::SupplyDaylightProp(), Landscape::SupplyNightProp(), Landscape::SupplySnowDepth(), tolr_bodycondition, tolr_leanweight, and CfgFloat::value().

Referenced by BeginStep().

Step()

void Goose_Base::Step ( void  )

virtual

The Step is the second 'part' of the timestep that an animal can behave in. It is called continuously until all animals report that they are 'DONE'.

Reimplemented from TAnimal.

Reimplemented in Goose_Pinkfoot_NonBreeder, Goose_Pinkfoot_FamilyGroup, Goose_Greylag_NonBreeder, Goose_Greylag_FamilyGroup, Goose_Barnacle_NonBreeder, and Goose_Barnacle_FamilyGroup.

{
    m_OurLandscape->Warn("Goose_Base::Step()","attempt to instantiate and use the base class!");
    exit(1);
}

References TAnimal::m_OurLandscape, and Landscape::Warn().

SubtractBodyCondition()

void Goose_Base::SubtractBodyCondition ( double  a_condition )

inline

Alters body conditon by subtraction of a double value.

{ m_TheBodyCondition -= a_condition; }

References m_TheBodyCondition.

Referenced by StartDay().

Member Data Documentation

CurrentGState

TTypeOfGoose_BaseState Goose_Base::CurrentGState

protected

Variable to record current behavioural state.

A Goose_Base must have some simple functionality: Inititation Movement Dying

Inherits m_Location_x, m_Location_y, m_OurLandscape from TAnimal NB All areas are squares of size length X length

Referenced by On_Bang(), On_Emigrate(), On_Migrate(), Goose_Barnacle_FamilyGroup::Step(), Goose_Barnacle_NonBreeder::Step(), Goose_Greylag_FamilyGroup::Step(), Goose_Greylag_NonBreeder::Step(), Goose_Pinkfoot_FamilyGroup::Step(), and Goose_Pinkfoot_NonBreeder::Step().

m_BMR

double Goose_Base::m_BMR

protected

The daily BMR.

Referenced by Goose_Barnacle_Base::Init(), Goose_Greylag_Base::Init(), Goose_Pinkfoot_Base::Init(), and StartDay().

m_BodyCondition

double Goose_Base::m_BodyCondition[5]

protected

A variable describing current body condition over the past 5 days.

Referenced by SetBodyCondition(), and StartDay().

m_BodyConditionCounter

unsigned Goose_Base::m_BodyConditionCounter

protected

A counter for the daily body condition.

Referenced by StartDay().

m_DailyMaxAppetite

double Goose_Base::m_DailyMaxAppetite

protected

The daily max kJ possible to get as intake.

Referenced by Goose_Barnacle_Base::Init(), Goose_Greylag_Base::Init(), Goose_Pinkfoot_Base::Init(), and st_Forage().

m_DailyMaxAppetiteHitTime

int Goose_Base::m_DailyMaxAppetiteHitTime

protected

The time of day when m_DailyMaxAppetite was hit.

Referenced by GetMaxAppetiteHitTime(), st_Forage(), and StartDay().

m_DEB

double Goose_Base::m_DEB

protected

The daily energy budget excluding flying (kJ)

Referenced by GetDailyEnergyBudget(), Goose_Barnacle_Base::Init(), Goose_Greylag_Base::Init(), Goose_Pinkfoot_Base::Init(), and StartDay().

m_energyReserve

double Goose_Base::m_energyReserve

protected

The bird's energy reserves in grams.

Referenced by StartDay().

m_energyToday

double Goose_Base::m_energyToday

protected

The bird's daily energy account (kJ)

Referenced by FlyTo(), GetDailyEnergyExpenditure(), st_Forage(), and StartDay().

m_flightcost

double Goose_Base::m_flightcost = -1

staticprotected

The cost of flight per g per m in kJ.

but with correct values.

Referenced by GetFlightCost(), and SetFlightCost().

m_FlightDistance

int Goose_Base::m_FlightDistance

protected

Storage for the total distance flown per day.

Referenced by FlyTo(), GetFlightDistance(), and StartDay().

m_FlightNumber

int Goose_Base::m_FlightNumber

protected

Counter for the number of flights per day.

Referenced by FlyTo(), GetFlightNumber(), and StartDay().

m_followinglikelyhood

int Goose_Base::m_followinglikelyhood = { -1, -1, -1 , -1, -1, -1 }

staticprotected

An attribute used to determine the chance of following or exploring when foraging.

Referenced by Set_GooseFollowingLikelyhood(), and st_ChooseForageLocation().

m_forageLocCount

int Goose_Base::m_forageLocCount

protected

The number of forage locations visited today.

Referenced by st_ChooseForageLocation(), and StartDay().

m_GooseFattoKJConversion

double Goose_Base::m_GooseFattoKJConversion = -1

staticprotected

Conversion rate fat to kJ.

Referenced by Set_GooseFattoKJConversion(), and StartDay().

m_GooseFieldForageDist

double Goose_Base::m_GooseFieldForageDist = { -1, -1, -1 }

staticprotected

The maximum distance travelled from roost to forage sites for each species of goose (m)

Referenced by Goose_Barnacle_Base::ChooseHopLoc(), Goose_Pinkfoot_Base::ChooseHopLoc(), and Set_GooseFieldForageDist().

m_GooseFieldForageDistX2

double Goose_Base::m_GooseFieldForageDistX2 = { -1, -1, -1 }

staticprotected

Double the maximum distance travelled from roost to forage sites for each species of goose (m) - this is a speed optimisation.

Referenced by Goose_Barnacle_Base::ChooseHopLoc(), Goose_Pinkfoot_Base::ChooseHopLoc(), and Set_GooseFieldForageDist().

m_GooseForageDist

double Goose_Base::m_GooseForageDist = { -1, -1, -1 }

staticprotected

The maximum distance travelled from roost to forage sites for each species of goose (m)

Referenced by Goose_Barnacle_Base::ChooseHopLoc(), Goose_Greylag_Base::ChooseHopLoc(), Goose_Pinkfoot_Base::ChooseHopLoc(), and Set_GooseForageDist().

m_GooseForageDistX2

double Goose_Base::m_GooseForageDistX2 = { -1, -1, -1 }

staticprotected

Double the maximum distance travelled from roost to forage sites for each species of goose (m) - this is a speed optimisation.

Referenced by Goose_Barnacle_Base::ChooseHopLoc(), Goose_Greylag_Base::ChooseHopLoc(), Goose_Pinkfoot_Base::ChooseHopLoc(), and Set_GooseForageDist().

m_GooseKJtoFatConversion

double Goose_Base::m_GooseKJtoFatConversion = -1

staticprotected

Conversion rate kJ to fat.

Referenced by Set_GooseKJtoFatConversion(), and StartDay().

m_GooseLeavingThreshold

double Goose_Base::m_GooseLeavingThreshold = -1

staticprotected

The trigger for leaving as a 5 day average of body condition.

Referenced by Set_GooseLeavingThreshold(), and StartDay().

m_GooseMaxAppetiteScaler

double Goose_Base::m_GooseMaxAppetiteScaler = -1

staticprotected

Scaler to determine the max kJ possible to eat per day based on non-energy reserve weight.

Referenced by Goose_Barnacle_Base::Init(), Goose_Greylag_Base::Init(), Goose_Pinkfoot_Base::Init(), and Set_GooseMaxAppetiteScaler().

m_GooseMaxEnergyReserveProportion

double Goose_Base::m_GooseMaxEnergyReserveProportion = -1

staticprotected

Max proportion of weight that can be energy reserve.

Referenced by Set_GooseMaxEnergyReserveProportion(), and StartDay().

m_GooseMinForageOpenness

double Goose_Base::m_GooseMinForageOpenness = -1

staticprotected

The minimum openness value a goose will tolerate for forage.

Referenced by EvaluateForageToHopLoc(), and Set_GooseMinForageOpenness().

m_groupsize

int Goose_Base::m_groupsize

protected

The size of the group this bird represents.

Referenced by GetGroupsize(), Goose_Barnacle_NonBreeder::Init(), Goose_Greylag_NonBreeder::Init(), Goose_Pinkfoot_NonBreeder::Init(), Goose_Barnacle_FamilyGroup::Init(), Goose_Greylag_FamilyGroup::Init(), Goose_Pinkfoot_FamilyGroup::Init(), Goose_Barnacle_FamilyGroup::KillThis(), Goose_Greylag_FamilyGroup::KillThis(), Goose_Pinkfoot_FamilyGroup::KillThis(), On_Bang(), ScaleForageToGroupsize(), st_ChooseForageLocation(), st_Forage(), Goose_Barnacle_Base::st_ToRoost(), Goose_Greylag_Base::st_ToRoost(), Goose_Pinkfoot_Base::st_ToRoost(), and StartDay().

m_Indivmingooseforagerate

double Goose_Base::m_Indivmingooseforagerate

protected

The minimum tolerable forage rate in kJ/minute for the individual.

Referenced by Set_Indivmingooseforagerate(), st_ChooseForageLocation(), and st_Forage().

m_LeaveRoostTime

double Goose_Base::m_LeaveRoostTime

protected

Controls the time when the goose will leave the roost.

Referenced by GetRoostLeaveTime(), st_Roost(), and StartDay().

m_LeavingRoost

bool Goose_Base::m_LeavingRoost

protected

Flag to indicate that we are coming from the roost. Used to control code for "following".

Referenced by Set_GooseLeavingRoost(), and st_ChooseForageLocation().

m_MaxIntakeSource

TMaxIntakeSource Goose_Base::m_MaxIntakeSource

protected

Holds information about the food source which gave max intake rate.

Referenced by GetMaxForageRate(), GetMaxIntakeSource(), and st_Forage().

m_mingooseforagerate

double Goose_Base::m_mingooseforagerate = { -1, -1, -1 }

staticprotected

The minimum tolerable forage rate in kJ/minute for the species.

Referenced by GetGooseMinForageRate(), and Set_mingooseforagerate().

m_myForageIndex

int Goose_Base::m_myForageIndex

protected

Temporary storage for a forage location index - this is a speed optimisation.

Referenced by GetForageLocIndex(), KillThis(), Goose_Barnacle_FamilyGroup::KillThis(), Goose_Greylag_FamilyGroup::KillThis(), Goose_Pinkfoot_FamilyGroup::KillThis(), On_Bang(), st_ChooseForageLocation(), st_Forage(), Goose_Barnacle_Base::st_ToRoost(), Goose_Greylag_Base::st_ToRoost(), and Goose_Pinkfoot_Base::st_ToRoost().

m_myGooseSpeciesType

GooseSpeciesType Goose_Base::m_myGooseSpeciesType

protected

Holds the goose species type.

Referenced by Goose_Barnacle_NonBreeder::Init(), Goose_Greylag_NonBreeder::Init(), Goose_Pinkfoot_NonBreeder::Init(), Goose_Barnacle_FamilyGroup::Init(), Goose_Greylag_FamilyGroup::Init(), Goose_Pinkfoot_FamilyGroup::Init(), KillThis(), Goose_Barnacle_FamilyGroup::KillThis(), Goose_Greylag_FamilyGroup::KillThis(), Goose_Pinkfoot_FamilyGroup::KillThis(), On_Bang(), On_Migrate(), st_ChooseForageLocation(), st_Forage(), Goose_Barnacle_Base::st_ToRoost(), Goose_Greylag_Base::st_ToRoost(), and Goose_Pinkfoot_Base::st_ToRoost().

m_MyMemory

GooseMemoryMap* Goose_Base::m_MyMemory

protected

The Goose Memory.

Referenced by EvaluateForageToHopLoc(), Goose_Barnacle_FamilyGroup::KillThis(), Goose_Greylag_FamilyGroup::KillThis(), Goose_Pinkfoot_FamilyGroup::KillThis(), On_Bang(), st_ChooseForageLocation(), st_Dying(), st_Forage(), StartDay(), and ~Goose_Base().

m_myMemPolyID

int Goose_Base::m_myMemPolyID

protected

Temporary storage for a memory location polygon id.

Referenced by st_ChooseForageLocation(), and st_Forage().

m_MyRoost

APoint Goose_Base::m_MyRoost

protected

The current roost location.

Referenced by ChooseHopLoc(), Goose_Barnacle_Base::ChooseHopLoc(), Goose_Greylag_Base::ChooseHopLoc(), Goose_Pinkfoot_Base::ChooseHopLoc(), EvaluateForageToHopLoc(), GetRoost(), On_Bang(), st_ChooseForageLocation(), Goose_Barnacle_Base::st_ToRoost(), Goose_Greylag_Base::st_ToRoost(), and Goose_Pinkfoot_Base::st_ToRoost().

m_myspecies

GooseSpecies Goose_Base::m_myspecies

protected

Holds goose species.

Referenced by EvaluateForageToHopLoc(), GetSpecies(), Goose_Barnacle_Base::Init(), Goose_Greylag_Base::Init(), Goose_Pinkfoot_Base::Init(), st_ChooseForageLocation(), st_Forage(), and StartDay().

m_OurPopulationManager

Goose_Population_Manager* Goose_Base::m_OurPopulationManager

protected

This is a time saving pointer to the correct population manager object.

Referenced by Goose_Barnacle_Base::ChangeRoost(), Goose_Greylag_Base::ChangeRoost(), Goose_Pinkfoot_Base::ChangeRoost(), EvaluateForageToHopLoc(), Goose_Barnacle_Base::Init(), Goose_Greylag_Base::Init(), Goose_Pinkfoot_Base::Init(), KillThis(), Goose_Barnacle_FamilyGroup::KillThis(), Goose_Greylag_FamilyGroup::KillThis(), Goose_Pinkfoot_FamilyGroup::KillThis(), On_Bang(), On_Migrate(), st_ChooseForageLocation(), st_Forage(), st_Roost(), Goose_Barnacle_Base::st_ToRoost(), Goose_Greylag_Base::st_ToRoost(), Goose_Pinkfoot_Base::st_ToRoost(), and StartDay().

m_sex

bool Goose_Base::m_sex

protected

Sex of bird, true = male false = female.

Referenced by GetSex(), and SetSex().

m_SnowDepth

double Goose_Base::m_SnowDepth = 0.0

staticprotected

The current snow depth. Held here for speed optimization.

Referenced by AdjustIntakeRateToSnowDepth(), and StartDay().

m_TheBodyCondition

double Goose_Base::m_TheBodyCondition

protected

A variable describing current body condition averaged over 5 days.

Referenced by AddBodyCondition(), GetBodyCondition(), StartDay(), and SubtractBodyCondition().

m_weight

double Goose_Base::m_weight

protected

The weight of the bird in gram excluding fat reserve.

Referenced by StartDay().

m_weightTotal

double Goose_Base::m_weightTotal

protected

The weight of the bird in g including fat reserve.

Referenced by GetFlightCost(), GetTotalWeight(), and StartDay().

---

The documentation for this class was generated from the following files:

• /builds/a1mass/almass_stable_oddox/GooseManagement/Goose_Base.h
• /builds/a1mass/almass_stable_oddox/GooseManagement/Goose_Base.cpp